home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / c / stut_src / sercomnd.c < prev    next >
C/C++ Source or Header  |  1996-05-27  |  12KB  |  508 lines
  1. /*
  2.  * SerComnd.c
  3.  *
  4.  * Traitement des commandes utilisateur
  5.  *
  6.  * 15.03.95: Created
  7.  */
  8.  
  9.  
  10.      #include "!OPTIONS.H"                /* Options de compilation */         
  11.     #define    THIS_FILE    "SERCOMND.C v1.00 - 02.95"
  12.           
  13.  
  14. /*
  15.  * System headers:
  16.  */
  17.     #include    <stdio.h>
  18.     #include    <string.h>
  19.     #include    <stdlib.h>
  20.  
  21. /*
  22.  * Custom headers:
  23.  */
  24.     #include    "MINITEL.H"
  25.     #include    "DEF_ARBO.H" 
  26.  
  27.     #include "SPEC_PU.H"
  28.  
  29.     #include "DEBUG_PU.H"
  30.     #include "SERV_PU.H"
  31.     #include    "LECTM_PU.H"
  32.     #include "TEXT_PU.H"
  33.     #include    "IOFLD_PU.H"
  34.     #include "ARBKEYPU.H"
  35.     #include "LINE0_PU.H"
  36.     #include "POPUP_PU.H"
  37.     #include "TERM_PU.H"
  38.     #include "LISTD_PU.H"    
  39.     #include    "SRIAL_PU.H"
  40.     #include "SERCOMPU.H"
  41.     #include "LISTS_PU.H"
  42.  
  43.     static    int    M_key_link[]=
  44.         {
  45.         /*    KEY_NONE,    */    NIL,            /* Aucune touche n'a ‚t‚ press‚e */ 
  46.         /*    KEY_SOMM,    */    FL_SOMM,
  47.         /*    KEY_GUIDE,    */    FL_GUIDE,
  48.         /*    KEY_ANNUL,    */    FL_ANNUL,
  49.         /*    KEY_CORREC,    */    FL_CORREC,
  50.         /*    KEY_RETOUR,    */    FL_RETOUR,
  51.         /*    KEY_SUITE,    */    FL_SUITE,
  52.         /*    KEY_REPET,    */    FL_REPET,
  53.         /*    KEY_ENVOI,    */    FL_ENVOI
  54.         };
  55.      
  56.  
  57. /*
  58.  * ----------------------------- METHODES ----------------------------
  59.  */
  60.  
  61. /*
  62.  * extract_number(-)
  63.  *
  64.  * Extrait un nombre en debut de chaine de caractŠres:
  65.  *
  66.  * 15.03.95: created
  67.  */
  68. BOOL    extract_number(                /* Out: TRUE si OK */
  69.             const char * cpsz,        /* In:  chaine de caractŠres */
  70.             long          * pl_number )/* Out: nombre trouv‚ */
  71. {
  72.     char    car;
  73.     int    i;
  74.     
  75.     if( cpsz == NULL )
  76.     {
  77.         return    FALSE0;
  78.     }
  79.     
  80.     for( i=0;
  81.             (car = cpsz[i]) != '\0';
  82.               i++ )
  83.     {
  84.         if( car>='0' && car <='9' )
  85.         {
  86.             *pl_number = atol( cpsz );
  87.             return    TRUE_1;
  88.         }
  89.         
  90.         if( car != ' ' )
  91.         {
  92.             return    FALSE0;
  93.         }
  94.         
  95.     }
  96.     
  97.     return    FALSE0;
  98. }
  99.  
  100.  
  101. /*
  102.  * Command_DelRecord(-)
  103.  *
  104.  * Purpose:
  105.  * --------
  106.  * Commande Delete d‚terminant l'effacement
  107.  *
  108.  * History:
  109.  * --------
  110.  * 15.03.95: fplanque: Created
  111.  */
  112. BOOL    Command_DelRecord(                /* Out: !FALSE si succŠs */
  113.             VOIE    *    pVoie_curr,            /* In:  Voie concern‚e */
  114.             char    *    piBsz_Arguments )    /* In:  Arguments pass‚s derriŠre la commande */
  115. {
  116.     switch( (pVoie_curr -> arboparams) -> fnct_no )
  117.     {    /*
  118.          * Selon la fonction de la page arbo: 
  119.          */
  120.         case    FA_LECT_MSG:
  121.             /*
  122.              * Effacement du message courament affich‚ … l'‚cran:
  123.              */
  124.             return    LectMsg_EraseCurrRec( pVoie_curr );        
  125.     
  126.         case    FA_LIST:
  127.         case    FA_DIRECTORY:
  128.             /*
  129.              * Effacement du record donn‚ en paramŠtre:
  130.              */
  131.             return    ListDB_CmdDelRec( pVoie_curr, piBsz_Arguments );    
  132.                 
  133.         default:
  134.             add_textinf( pVoie_curr -> wi_params, "WARNING: Action appell‚e hors-contexte!" );
  135.     }
  136.  
  137.  
  138.     /*
  139.      * On a ps pu ‚x‚cuter:
  140.      */
  141.     return    FALSE0;
  142. }
  143.  
  144.  
  145. /*
  146.  * Serv_DoAction()
  147.  *
  148.  * Execute une action
  149.  *
  150.  * 31.03.95: fplanque: Created
  151.  */
  152. BOOL Serv_DoAction(
  153.             VOIE    *    pVoie_curr,        /* In:  Voie concern‚e */
  154.             int        n_Action,
  155.             char    *    psz_more,        /* In:  Plus d'arguments */
  156.             BOOL    *    b_CsrMoved )
  157. {
  158.     BOOL                    b_ActionSuccess = TRUE_1;    /* Par d‚faut */
  159.  
  160.     if( n_Action != ACTION_NONE ) 
  161.     { 
  162.         sprintf( G_tmp_buffer, "   Action: %s", get_popup_name( G_Popup_ActionMenu, n_Action ) );
  163.         add_textinf( pVoie_curr -> wi_params, G_tmp_buffer );
  164.     
  165.         switch( n_Action )
  166.         {
  167.             case    ACTION_CLS:
  168.                 cconout( pVoie_curr -> device, FF );
  169.                 *b_CsrMoved = TRUE_1;
  170.                 break;
  171.                 
  172.             case    ACTION_FULLCLS:
  173.                 Serial_FlushTX( pVoie_curr -> device );
  174.                 full_cls( pVoie_curr -> device );
  175.                 *b_CsrMoved = TRUE_1;
  176.                 break;
  177.                 
  178.             case    ACTION_2BOMBES:
  179.             {    /*
  180.                  * Provoque un plantage g‚n‚ral volontaire !!! (2 Bombes)
  181.                  */
  182.                 char * ptr = NULL;
  183.                 *ptr = *ptr;
  184.                 break;
  185.             }
  186.             
  187.             case    ACTION_DEL_RECORD:
  188.                 /*
  189.                  * Effacement d'un enregistrement:
  190.                  */
  191.                 b_ActionSuccess = Command_DelRecord( pVoie_curr, psz_more );
  192.                 break;
  193.                 
  194.             default:
  195.                 signale( "Ne sait pas traiter l'action demand‚e" );
  196.         }
  197.     }
  198.  
  199.     return b_ActionSuccess;
  200. }
  201.  
  202. /*
  203.  * Serv_ExecuteCommand(-)
  204.  *
  205.  * Appell‚ par mot clef ou ‚vŠnement
  206.  * D‚clenche les actions associ‚es
  207.  *
  208.  * 31.03.95: fplanque: Created
  209.  * 12.07.95: fplanque: renvoie un bool‚un indiquant si on a fait un JUMP ou non
  210.  * 14.10.95: fplanque: ne fait pas de JUMP si la page destination est une chaine vide
  211.  */
  212. BOOL    Serv_ExecuteCommand(                        /* Out: TRUE_1 si on a fait un JUMP */
  213.             VOIE                *    pVoie_curr,        /* In:  Voie concern‚e */
  214.             KEYWORD_LIST     *    p_Command,        /* In:  Commande … traiter */
  215.             char                *    psz_more )        /* In:  Plus d'arguments */
  216. {
  217.     BOOL            b_CsrMoved = FALSE0;
  218.  
  219.     /*
  220.      * Action 1 associ‚e … la touche/mot clef:
  221.      */
  222.     if( Serv_DoAction( pVoie_curr, p_Command -> n_Action1, psz_more, &b_CsrMoved ) == TRUE_1 )
  223.     {    /*
  224.          * Nlle page arbo associ‚e … la touche:
  225.          */
  226.         char    *    new_page = p_Command -> psz_DestPage;    
  227.     
  228.         if( new_page != NULL && new_page != G_empty_string && new_page[0] != '\0' )
  229.         {    /*
  230.              * Si une page est associ‚e au mot clef:
  231.              * Action 2 associ‚e … la touche/mot clef:
  232.              */
  233.             if( Serv_DoAction( pVoie_curr, p_Command -> n_Action2, psz_more, &b_CsrMoved ) == TRUE_1 )
  234.             {    /*
  235.                  * Passe en phase de changement de page:
  236.                  */
  237.                 register_action( pVoie_curr, JUMP, 0, 0, new_page );    
  238.                 return TRUE_1;
  239.             }
  240.         }
  241.     }
  242.     
  243.     if( b_CsrMoved == TRUE_1 )
  244.     {    /*
  245.          * Pas de saut de page
  246.          * MAIS on a boug‚ le curseur:
  247.          * il faut le remettre en place:
  248.          */
  249.         place_csr( pVoie_curr );
  250.     }
  251.  
  252.     return    FALSE0;
  253. }
  254.  
  255.  
  256.  
  257. /*
  258.  * serv_handleKeyword(-)
  259.  *
  260.  * Purpose:
  261.  * --------
  262.  * Analyse ligne de commande et d‚termine s'il s'agit d'un mot clef
  263.  * execute l'action voulue
  264.  * et demande de se rendre … l'endroit voulu
  265.  *
  266.  * Algorythm:
  267.  * ----------  
  268.  * - cherche si on connait le MC
  269.  * - exec action
  270.  *
  271.  * History:
  272.  * --------
  273.  * 24.05.94: fplanque: Created
  274.  * 27.11.94: ne fait rien si on est pas en cours d'‚dition
  275.  * 05.12.94: introduced c_KeywordIdentifier
  276.  * 30.01.95: coupe params derriŠre le mot clef
  277.  * 15.03.95: traite commandes; corrig‚ bug detection pas de destination
  278.  * 28.03.95: gestion position curseur am‚lior‚e
  279.  * 12.07.95: fplanque: la gestion de csr ci-dessus entrainait des actions en trop (et des bugs) si l'action produisait un JUMP: rajout‚ le test n‚cessaire
  280.  */
  281. BOOL    serv_handleKeyword(                            /* Out: FALSE0 si pas de mot clef … traiter */
  282.                 VOIE    *    pVoie_curr,                    /* In: Voie concern‚e */
  283.                 char        c_KeywordIdentifier )    /* In: car obligatoire en d‚but de champ pour indiquer que c'est un mot clef ou bien '\0' */
  284. {
  285.     PAGEARBO            *    pPgArbo_curr;
  286.     KEYWORD_LIST    *    pDTL_MotsClefs;
  287.     KEYWORD_LIST     *    pDTL_MotClef;
  288.     const char        *    cpBsz_CmdLine;
  289.     char                *    pisz_Separator;
  290.     
  291.     if( GetEditMode( pVoie_curr ) != FIELDEDIT )
  292.     {    /*
  293.          * S'il n'y a pas de champ d'‚dition, 
  294.          * il n'y a aucune chance qu'on ait tap‚ un mot clef! :
  295.          */
  296.         return    FALSE0;
  297.     }
  298.  
  299.     /*
  300.      * Obtient ligne de commande:    (NE PAS MODIFIER la ligne de commande!)
  301.      */
  302.     cpBsz_CmdLine = aim_CurrField( pVoie_curr );
  303.     
  304.     if( cpBsz_CmdLine[0] == '\0' )
  305.     {    /*
  306.          * Si la ligne est vide:
  307.          */
  308.         return    FALSE0;
  309.     }
  310.  
  311.     if( c_KeywordIdentifier && cpBsz_CmdLine[0] != c_KeywordIdentifier )
  312.     {    /*
  313.          * La ligne ne commence pas par le car exig‚ pour Mot clef
  314.          * donc on considŠre que c'est pas un mot clef!
  315.          */
  316.         return    FALSE0;
  317.     }
  318.  
  319.     /*
  320.      * Recopie ligne de commande dans le tmp buffer:
  321.      */
  322.     strncpy( G_2nd_buffer, cpBsz_CmdLine, SECOND_BUFFER_SIZE );
  323.     G_2nd_buffer[ SECOND_BUFFER_SIZE ] = '\0';
  324.     /* printf("\nCommand line: %s\n", G_2nd_buffer );*/
  325.     
  326.     pisz_Separator = strchr( G_2nd_buffer, ' ' );
  327.     if( pisz_Separator != NULL )
  328.     {    /*
  329.          * Coupe les params derriŠre le mot clef:
  330.          */
  331.         *(pisz_Separator++) = '\0';
  332.         /* printf( "Params= %s\n", pisz_Separator ); */
  333.     }
  334.  
  335.     /*
  336.      * S'il y a un mot clef sur la ligne:
  337.      * ParamŠtres de la page arbo courante 
  338.      */
  339.     pPgArbo_curr = pVoie_curr -> arboparams;
  340.     pDTL_MotsClefs = pPgArbo_curr -> p_MotsClefs;        /* Ptr sur liste de Mots clefs */
  341.     
  342.     /*
  343.      * Cherche mot clef:
  344.      */
  345.     pDTL_MotClef = findElt_KWLst_by1stName( pDTL_MotsClefs, G_2nd_buffer );
  346.  
  347.     if( pDTL_MotClef == NULL )
  348.     {    /*
  349.           * Mot clef non reconnu:
  350.           */
  351.         aff_msg_l0( pVoie_curr, "Commande invalide!" );
  352.         
  353.         /*
  354.           * Note: on considŠre que l'action a ‚t‚ correctement trait‚e!:
  355.           */
  356.         return    TRUE_1;
  357.     }
  358.     
  359.     /*
  360.      * Affiche Mot clef sur moniteur:
  361.      */
  362.     sprintf( G_tmp_buffer, "  Commande: %s", cpBsz_CmdLine );
  363.     add_textinf( pVoie_curr -> wi_params, G_tmp_buffer );
  364.  
  365.     /*
  366.      * Ex‚cute commande associ‚e au mot clef:
  367.      */
  368.     if( Serv_ExecuteCommand( pVoie_curr, pDTL_MotClef, pisz_Separator ) == FALSE0 )
  369.     {    /*
  370.           * La commande a ‚t‚ prise en compte mais n'a pas entraŒn‚ de JUMP:
  371.          * on efface le champ de saisie et on attend la prochaine:
  372.          */
  373.         register_action( pVoie_curr, CLRF, 0, 0, pVoie_curr -> pIOField_CurrIn );        
  374.         register_action( pVoie_curr, WAIT, 0, 0, NULL );        /* Repasse en mode d'attente d'action */
  375.     }
  376.     
  377.     return    TRUE_1;
  378. }
  379.  
  380.  
  381. /*
  382.  * keyaction_std(-)
  383.  *
  384.  * Purpose:
  385.  * --------
  386.  * R‚agit … la touche press‚ sur une page standard
  387.  *
  388.  * History:
  389.  * --------
  390.  * fplanque: Created
  391.  * 24.05.94: Gestion desmots clefs
  392.  */
  393. void    keyaction_std(
  394.             KEYCODE     curr_keypress, 
  395.             VOIE *    pVoie_curr )
  396. {
  397.  
  398.     switch( curr_keypress )
  399.     {
  400.         case    KEY_ENVOI:    
  401.             if( ! serv_handleKeyword( pVoie_curr, '\0' ) )
  402.             {    /*
  403.                  * Si pas de mot clef:
  404.                  * Action par d‚faut de la touche envoi:
  405.                  */
  406.                 affiche_touche( pVoie_curr, curr_keypress );        /* Affiche nom de la touche */
  407.         
  408.                 /*
  409.                  * Demande Changement de page:
  410.                  */
  411.                 follow_KeyArboLink( pVoie_curr, curr_keypress );
  412.             }
  413.             break;
  414.                     
  415.         case    KEY_RETOUR:
  416.         case    KEY_REPET:
  417.         case    KEY_GUIDE:
  418.         case    KEY_ANNUL:
  419.         case    KEY_SOMM:
  420.         case    KEY_CORREC:
  421.         case    KEY_SUITE:
  422.             affiche_touche( pVoie_curr, curr_keypress );        /* Affiche nom de la touche */
  423.             /*
  424.              * Demande Changement de page:
  425.              */
  426.             follow_KeyArboLink( pVoie_curr, curr_keypress );
  427.             break;
  428.  
  429.     }
  430.  
  431. }
  432.  
  433.  
  434.  
  435.  
  436. /*
  437.  * follow_KeyArboLink(-)
  438.  *
  439.  * Purpose:
  440.  * --------
  441.  * Provoque un JUMP correspondant au lien arbo
  442.  * associ‚ … la touche donn‚e
  443.  *
  444.  * Algorythm:
  445.  * ----------  
  446.  *    -Cherche paramŠtres de la touche
  447.  *
  448.  * History:
  449.  * --------
  450.  * 24.05.94: fplanque: Created
  451.  * 30.01.95: appel de follow_ArboLink()
  452.  */
  453. void    follow_KeyArboLink(
  454.                 VOIE *    pVoie_curr,            /* In: Voie en cours de traitement */
  455.                 KEYCODE    curr_keypress )    /* In: Code touche … suivre */
  456. {
  457.     /* 
  458.      * Num‚ro de fonction du lien associ‚ … cette touche:
  459.      */
  460.     int    currlink_fnctno = M_key_link[ curr_keypress ];    
  461.  
  462.     follow_ArboLink( pVoie_curr, currlink_fnctno );
  463. }                
  464.  
  465.  
  466.  
  467.  
  468. /*
  469.  * follow_ArboLink(-)
  470.  *
  471.  * Purpose:
  472.  * --------
  473.  * Provoque un JUMP correspondant au lien arbo de fonction demand‚e
  474.  *
  475.  * History:
  476.  * --------
  477.  * 30.01.95: fplanque: Created based on follow_KeyArboLink()
  478.  * 29.03.95: quickchanged to use KEYWORD_LIST
  479.  * 31.03.95: appel de Serv_ExecuteCommand()
  480.  * 14.10.95: renvoie TRUE_1 uniquement s'il y a eu un JUMP
  481.  */
  482. BOOL    follow_ArboLink(                    /* In: TRUE_1 si on a fait un JUMP */
  483.                 VOIE *    pVoie_curr,        /* In: Voie en cours de traitement */
  484.                 int        n_FnctLink )    /* In: Fonction lien demand‚e */
  485. {
  486.     /*
  487.      *    Trouve les paramŠtres de la touche:
  488.      */
  489.     DATAPAGE         *    curr_page = pVoie_curr -> arbopage;
  490.     PAGEARBO         *    curr_arbopar = curr_page -> data.pagearbo;
  491.     KEYWORD_LIST *    key_params = Lookup_SingleLinkList( curr_arbopar -> p_Events, n_FnctLink );
  492.  
  493.     if( key_params != NULL )
  494.     {    /*
  495.          * Si une commande est associ‚e … la fonction lien demand‚e:
  496.          * Ex‚cute commande associ‚e … l'‚vŠnement:
  497.          */
  498.         if( Serv_ExecuteCommand( pVoie_curr, key_params, NULL ) )
  499.         {
  500.             return TRUE_1;
  501.         }
  502.     }
  503.  
  504.     return    FALSE0;
  505. }                
  506.  
  507.  
  508.